home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: delta / whiteline CD Series - delta.iso / tools / falc_uti / dsp_tool / dsp_unit / dsp_conv.s < prev    next >
Encoding:
Text File  |  1995-11-25  |  5.5 KB  |  215 lines
  1.  
  2.             export r_frac,to_real,e_frac,to_ext,to_single,s_frac
  3.                     
  4.             mc68881
  5.         
  6. r_frac:        move.w    4(sp),d1        ;REAL-Exponent    
  7.             move.l    6(sp),d0        ;REAL-Mantisse (nur die obersten 32 Bit)
  8.             bra        weiter_1
  9.             
  10. e_frac:        lea        extpuf,a0
  11.             fmove.x    fp0,(a0)
  12.             move.w    (a0),d1            ;EXTENDED-Exponent
  13.             move.l    4(a0),d0        ;EXTENDED-Mantisse (wie REAL nur verschoben)
  14. weiter_1:    move.w    d1,d2
  15.             bclr    #15,d2            ;Vorzeichen löschen
  16.             sub.w    #16383,d2        ;Offset vom Exponenten abziehen
  17.             bpl     r_gross            ;Poistiver Exponent -> Zahl zu groß
  18.             neg        d2
  19.             cmpi.w    #23,d2            ;mehr als 23 Stellen zu Schieben ?
  20.             bgt        r_klein            ;dann ist Zahl zu nahe an 0
  21.             addq.w    #8,d2            ;Die ersten 8 Bit des LWORDS sind 0
  22.             lsr.l    d2,d0            ;Mantisse an die richtige Stelle schieben
  23.             btst    #15,d1            ;Vorzeichen prüfen
  24.             beq        r_exit
  25.             eori.l    #$7fffff,d0        ;negatives VZ --> Zweierkomplement bilden
  26.             addq.l    #1,d0             ;Zahl invertieren und +1
  27.             bset    #23,d0            ;Vorzeichenbit setzen
  28. r_exit:        rts
  29. r_klein:    moveq    #0,d0            ;Zahl=0
  30.             rts
  31. r_gross:    btst    #15,d1            ;Zahl zu negativ oder zu positiv ?
  32.             bne        n_rzg
  33.             move.l    #$7fffff,d0        ;größte positive Zahl (0.9999...)
  34.             rts
  35. n_rzg:        move.l    #$800000,d0        ;größte negative Zahl (-1)
  36.             rts
  37.  
  38.                                     
  39. to_real:    movem.l    d3-d4,-(sp)
  40.             clr.w    d4
  41.             bra        weiter_2
  42.             
  43. to_ext:        movem.l    d3-d4,-(sp)
  44.             move.w    #1,d4
  45.             
  46. weiter_2:    tst.l    d0                ;Zahl =0 ?
  47.             beq        rnull            
  48.             cmpi.l    #$800000,d0        ;Zahl =-1 ?
  49.             beq        rm_1
  50.             bclr    #23,d0            ;Vorzeichen prüfen und löschen
  51.             bne     rminus            ;negative Zahl
  52.             move.w    #22,d1
  53. rloop_1:    btst    d1,d0            ;erstes gesetztes Bit von links suchen        
  54.             dbne    d1,rloop_1
  55.             move.w    #23,d2            ;Exponent zusammenbasteln
  56.             sub.w    d1,d2
  57.             move.w    #16383,d3        ;Offset addieren
  58.             sub.w    d2,d3
  59.             addq.w    #8,d2
  60.             lsl.l   d2,d0            ;Mantisse schieben
  61.             ori.w    #$1ff,d0        ;restliche Bits der Mantisse setzen
  62.             tst.w    d4
  63.             beq        weiter_3
  64.             lea        extpuf,a0
  65.             move.w    d3,(a0)
  66.             clr.w    2(a0)
  67.             move.l    d0,4(a0)
  68.             move.l    #-1,8(a0)
  69.             fmove.x    (a0),fp0
  70.             movem.l    (sp)+,d3-d4
  71.             rts
  72. weiter_3:   move.w    d3,(a0)+
  73.             move.l    d0,(a0)+
  74.             move.l  #-1,(a0)        ;Die unteren 32 Bits der Mantisse
  75.             movem.l    (sp)+,d3-d4
  76.             rts
  77.  
  78. rminus:        subq.l    #1,d0            ;Zweierkomplement rückgängig machen
  79.             eori.l    #$7fffff,d0
  80.             move.w    #22,d1
  81. rloop_2:    btst    d1,d0            ;Rest siehe oben        
  82.             dbne    d1,rloop_2
  83.             move.w    #23,d2            ;Exponent zusammenbasteln
  84.             sub.w    d1,d2
  85.             move.w    #16383,d3
  86.             sub.w    d2,d3
  87.             addq.w    #8,d2
  88.             lsl.l   d2,d0            ;Mantisse schieben
  89.             ori.w    #$1ff,d0        ;restliche Bits der Mantisse setzen
  90.             bset    #15,d3
  91.             tst.w    d4
  92.             beq        weiter_4
  93.             lea        extpuf,a0
  94.             move.w    d3,(a0)
  95.             clr.w    2(a0)
  96.             move.l    d0,4(a0)
  97.             move.l    #-1,8(a0)
  98.             fmove.x    (a0),fp0
  99.             movem.l    (sp)+,d3-d4
  100.             rts
  101. weiter_4:   move.w    d3,(a0)+
  102.             move.l    d0,(a0)+
  103.             move.l  #-1,(a0)        ;Die unteren 32 Bits der Mantisse
  104.             movem.l    (sp)+,d3-d4
  105.             rts            
  106.                         
  107. rnull:        tst.w    d4
  108.             beq        weiter_5
  109.             fmovecr    #$F,fp0
  110.             movem.l    (sp)+,d3-d4
  111.             rts
  112.             
  113. weiter_5:    clr.w    (a0)+
  114.             clr.l    (a0)+
  115.             clr.l    (a0)
  116.             movem.l    (sp)+,d3-d4
  117.             rts
  118.             
  119. rm_1:        tst.w    d4
  120.             beq        weiter_6
  121.             fmove.w    #-1,fp0
  122.             movem.l    (sp)+,d3-d4
  123.             rts
  124.             
  125. weiter_6:    move.w    #$bfff,(a0)+
  126.             move.l    #$80000000,(a0)+
  127.             clr.l    (a0)
  128.             movem.l    (sp)+,d3-d4
  129.             rts
  130.  
  131. s_frac:        move.l    4(sp),d0        ;Single-Zahl
  132.             move.l    d0,d1
  133.             swap    d1
  134.             lsr.w    #7,d1            ;Exponent
  135.             andi.l    #$7fffff,d0        ;Mantisse
  136.             bset    #23,d0            ;führende 1 setzen
  137.             move.w    d1,d2
  138.             bclr    #8,d2            ;Vorzeichen löschen
  139.             sub.w    #127,d2            ;Offset vom Exponenten abziehen
  140.             bpl     s_gross            ;Poistiver Exponent -> Zahl zu groß
  141.             neg        d2
  142.             cmpi.w    #23,d2            ;mehr als 23 Stellen zu Schieben ?
  143.             bgt        s_klein            ;dann ist Zahl zu nahe an 0
  144.             lsr.l    d2,d0            ;Mantisse an die richtige Stelle schieben
  145.             btst    #8,d1            ;Vorzeichen prüfen
  146.             beq        s_exit
  147.             eori.l    #$7fffff,d0        ;negatives VZ --> Zweierkomplement bilden
  148.             addq.l    #1,d0             ;Zahl invertieren und +1
  149.             bset    #23,d0            ;Vorzeichenbit setzen
  150. s_exit:        rts
  151. s_klein:    moveq    #0,d0            ;Zahl=0
  152.             rts
  153. s_gross:    btst    #8,d1            ;Zahl zu negativ oder zu positiv ?
  154.             bne        n_szg
  155.             move.l    #$7fffff,d0        ;größte positive Zahl (0.9999...)
  156.             rts
  157. n_szg:        move.l    #$800000,d0        ;größte negative Zahl (-1)
  158.             rts
  159.  
  160.                                     
  161. to_single:    move.l    d3,-(sp)
  162.             tst.l    d0                ;Zahl =0 ?
  163.             beq        snull            
  164.             cmpi.l    #$800000,d0        ;Zahl =-1 ?
  165.             beq        sm_1
  166.             bclr    #23,d0            ;Vorzeichen prüfen und löschen
  167.             bne     sminus            ;negative Zahl
  168.             move.w    #22,d1
  169. sloop_1:    btst    d1,d0            ;erstes gesetztes Bit von links suchen        
  170.             dbne    d1,sloop_1
  171.             moveq    #0,d3
  172.             move.w    #23,d2            ;Exponent zusammenbasteln
  173.             sub.w    d1,d2
  174.             move.w    #127,d3            ;Offset addieren
  175.             sub.w    d2,d3
  176.             lsl.l   d2,d0            ;Mantisse schieben
  177.             bclr    #23,d0            ;führende 1 löschen
  178.             lsl.w    #7,d3
  179.             swap    d3
  180.             or.l    d3,d0
  181.             move.l    d0,(a0)
  182.             move.l    (sp)+,d3
  183.             rts
  184.  
  185. sminus:        subq.l    #1,d0            ;Zweierkomplement rückgängig machen
  186.             eori.l    #$7fffff,d0
  187.             move.w    #22,d1
  188. sloop_2:    btst    d1,d0            ;Rest siehe oben        
  189.             dbne    d1,sloop_2
  190.             moveq    #0,d3
  191.             move.w    #23,d2            ;Exponent zusammenbasteln
  192.             sub.w    d1,d2
  193.             move.w    #127,d3
  194.             sub.w    d2,d3
  195.             lsl.l   d2,d0            ;Mantisse schieben
  196.             bclr    #23,d0            ;führende 1 löschen
  197.             bset    #8,d3            ;Vorzeichen
  198.             lsl.w    #7,d3
  199.             swap    d3
  200.             or.l    d3,d0
  201.             move.l    d0,(a0)
  202.             move.l    (sp)+,d3
  203.             rts            
  204.                         
  205. snull:        clr.l    (a0)
  206.             move.l    (sp)+,d3
  207.             rts
  208.             
  209. sm_1:        move.l    #$bf800000,(a0)
  210.             move.l    (sp)+,d3
  211.             rts
  212.  
  213. extpuf:        ds.l    3
  214.  
  215.             end